/**   
* @Title: DruidDbProperties.java 
* @Package com.yy.bg.properties 
* @author 邓启翔
* @date 2018年1月23日 下午3:12:59 
* @version V1.0   
*/
package com.guosen.zebra.database.mybatis.properties;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/** 
* @ClassName: DruidDbProperties 
* @author 邓启翔
* @date 2018年1月23日 下午3:12:59 
*  
*/
@Configuration
public class DruidDbProperties {
	
	@Value("${zebra.druid.driverClassName:com.mysql.jdbc.Driver}")
    private String driverClassName="com.mysql.jdbc.Driver";

    /**
     * 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
     */
	@Value("${zebra.druid.initialSize:10}")
    private int initialSize=10;

    /**
     * 最小连接池数量
     */
	@Value("${zebra.druid.minIdle:50}")
    private int minIdle=50;

    /**
     * 最大连接池数量
     */
	@Value("${zebra.druid.maxActive:300}")
    private int maxActive=300;

    /**
     * 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
     */
	@Value("${zebra.druid.maxWait:60000}")
    private int maxWait=60000;

    /**
     * 有两个含义： 1)
     * Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。 2)
     * testWhileIdle的判断依据，详细看testWhileIdle属性的说明
     */
	@Value("${zebra.druid.timeBetweenEvictionRunsMillis:60000}")
    private int timeBetweenEvictionRunsMillis=60000;

    /**
     * 连接保持空闲而不被驱逐的最长时间
     */
	@Value("${zebra.druid.minEvictableIdleTimeMillis:3600000}")
    private int minEvictableIdleTimeMillis=3600000;

    /**
     * 用来检测连接是否有效的sql，要求是一个查询语句，常用select
     * 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
     */
	@Value("${zebra.druid.validationQuery:SELECT 1}")
    private String validationQuery="SELECT 1";

    /**
     * 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
     */
	@Value("${zebra.druid.testWhileIdle:true}")
    private boolean testWhileIdle=true;

    /**
     * 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
     */
	@Value("${zebra.druid.testOnBorrow:false}")
    private boolean testOnBorrow =false;

    /**
     * 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
     */
	@Value("${zebra.druid.testOnReturn:false}")
    private boolean testOnReturn = false;

    /**
     * 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat 日志用的filter:log4j
     * 防御sql注入的filter:wall
     */
	@Value("${zebra.druid.filters:mergeStat,config,wall}")
    private String filters = "mergeStat,config,wall";

	
	@Value("${zebra.druid.filters:}")
    private String connectionProperties="";

    /**
     * 白名单
     */
	@Value("${zebra.druid.allow:}")
    private String allow="";

    /**
     * 黑名单
     */
	@Value("${zebra.druid.deny:}")
    private String deny="";

	public String getDriverClassName() {
		return driverClassName;
	}

	public void setDriverClassName(String driverClassName) {
		this.driverClassName = driverClassName;
	}

	public int getInitialSize() {
		return initialSize;
	}

	public void setInitialSize(int initialSize) {
		this.initialSize = initialSize;
	}

	public int getMinIdle() {
		return minIdle;
	}

	public void setMinIdle(int minIdle) {
		this.minIdle = minIdle;
	}

	public int getMaxActive() {
		return maxActive;
	}

	public void setMaxActive(int maxActive) {
		this.maxActive = maxActive;
	}

	public int getMaxWait() {
		return maxWait;
	}

	public void setMaxWait(int maxWait) {
		this.maxWait = maxWait;
	}

	public int getTimeBetweenEvictionRunsMillis() {
		return timeBetweenEvictionRunsMillis;
	}

	public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
		this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
	}

	public int getMinEvictableIdleTimeMillis() {
		return minEvictableIdleTimeMillis;
	}

	public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
		this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
	}

	public String getValidationQuery() {
		return validationQuery;
	}

	public void setValidationQuery(String validationQuery) {
		this.validationQuery = validationQuery;
	}

	public boolean isTestWhileIdle() {
		return testWhileIdle;
	}

	public void setTestWhileIdle(boolean testWhileIdle) {
		this.testWhileIdle = testWhileIdle;
	}

	public boolean isTestOnBorrow() {
		return testOnBorrow;
	}

	public void setTestOnBorrow(boolean testOnBorrow) {
		this.testOnBorrow = testOnBorrow;
	}

	public boolean isTestOnReturn() {
		return testOnReturn;
	}

	public void setTestOnReturn(boolean testOnReturn) {
		this.testOnReturn = testOnReturn;
	}

	public String getFilters() {
		return filters;
	}

	public void setFilters(String filters) {
		this.filters = filters;
	}

	public String getConnectionProperties() {
		return connectionProperties;
	}

	public void setConnectionProperties(String connectionProperties) {
		this.connectionProperties = connectionProperties;
	}

	public String getAllow() {
		return allow;
	}

	public void setAllow(String allow) {
		this.allow = allow;
	}

	public String getDeny() {
		return deny;
	}

	public void setDeny(String deny) {
		this.deny = deny;
	}

}
